home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / MACSHELL / MS1 / SHELL_SO / SHELLVAR.C < prev    next >
Text File  |  1992-12-02  |  10KB  |  374 lines
  1.  
  2. /*
  3.  *    MacShell Source File
  4.  *
  5.  *    Copyright (c) 1989, 1990, 1991, 1992  Suick Bay Technologies.  All rights reserved.
  6.  *
  7.  *
  8.  *    RESTRICTIONS ON MacShell program and source code.
  9.  *
  10.  *    Ñ╩MacShell¬ is a product of Suick Bay Technologies and is provided for
  11.  *    restricted use by the owner of the CDROM "Disk to the future II".
  12.  *
  13.  *    Ñ╩No permission is granted for any commercial use without the written
  14.  *    consent of the Suick Bay Technologies.
  15.  *
  16.  *    Ñ╩No permission is granted for any redistribution of any kind use without
  17.  *    the written consent of the Suick Bay Technologies.
  18.  *
  19.  *    Ñ╩Permission is granted to use this for any personal noncommercial use.
  20.  *
  21.  *    Ñ╩You may not distribute source or executable code at all, nor may you 
  22.  *    distribute it with or within a commercial product without the written
  23.  *    consent of the Suick Bay Technologies.  Please send modifications to 
  24.  *    the author for inclusion in updates to the program.  Thanks.
  25.  *
  26.  *
  27.  *    MacShell¬ IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  28.  *    WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  29.  *    PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  30.  *
  31.  *    SUICK BAY TECHNOLOGIES SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  32.  *    INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY MACSHELL
  33.  *    OR ANY PART THEREOF. 
  34.  *
  35.  *    In no event will Suick Bay Technologies be liable for any lost revenue
  36.  *    or profits or other special, indirect and consequential damages, even if
  37.  *    Suick Bay Technologies has been advised of the possibility of such damages.
  38.  *
  39.  *    Suick Bay Technologies can be reached at:
  40.  *    
  41.  *    8768 Cottonwood lane
  42.  *    Maple Grove, MN 55369
  43.  *    Voice: (612) 425-7025
  44.  *    AppleLink: D5233
  45.  *    
  46.  *
  47.  *    No parts of this software may be reproduced or stored in a
  48.  *    retrieval system or transmitted in any form, or any means,
  49.  *    electronic, mechanical, photocopying, recording or otherwise,
  50.  *    without the prior written permission of Suick Bay Technologies.
  51.  *    
  52.  *    Spread the word and not the disk.
  53.  *    
  54.  *    SPK 030790    :    Locked ch in ShellGetVar
  55.  *    SPK 012290    :    Initial
  56.  */
  57.  
  58. #include    "System.h"
  59. #include    "Global.h"
  60. #include    "Mac.h"
  61. #include    "Proc.h"
  62. #include    "Shell.h"
  63. #include    "Path.h"
  64. #include    "Global.h"
  65. #include    <OSUtil.h>
  66.  
  67. /*******************************************************************
  68.  *    
  69.  *******************************************************************/
  70.  
  71. Boolean        ShellSetVar( WHandle ShellWh, char *varName, char *value )
  72. {
  73. ShellWindRec    **MyShell;
  74. char            buf[ MAXVALUESIZE+8 ];
  75. int16            len;
  76.  
  77.     MyShell = (ShellWindRec **) (**(ShellWh)).thing;
  78.  
  79.     len = strlen( value );        /* clip the max size to our output buffer */
  80.     if( len > MAXVALUESIZE )
  81.         value[ MAXVALUESIZE ] = '\0';
  82.  
  83.     sprintf( buf, "%d_ _%s", (**MyShell).shellID, varName );
  84.     
  85.     RemShellString( buf );
  86.     AddShellString( buf, value );
  87.     return( TRUE );
  88. }
  89.  
  90. void        ShellDelVar( WHandle ShellWh, char *varName )
  91. {
  92. ShellWindRec    **MyShell;
  93. char            buf[ 256 ];
  94.  
  95.     MyShell = (ShellWindRec **) (**(ShellWh)).thing;
  96.     sprintf( buf, "%d_ _%s", (**MyShell).shellID, varName );
  97.     RemShellString( buf );
  98. }
  99.  
  100. /*******************************************************************/
  101.  
  102. char    tempValue[ MAXVALUESIZE ];
  103. #define    USERNAMEID    -16096
  104.  
  105. char    *ShellGetVar( WHandle ShellWh, char *varName )
  106. {
  107. int16            i, max;
  108. ShellWindRec    **MyShell;
  109.  
  110.     MyShell = (ShellWindRec **) (**(ShellWh)).thing;
  111. /*
  112.  *    Special Mac variables that are read only
  113.  *
  114.  *  BOOT            volume name of the boot disk
  115.  *  COMMAND         name of the last command executed
  116.  *  SHELL            full pathname of the Shell
  117.  *  SYSTEMFOLDER    full pathname of the system folder
  118.  *  USER            the current user name (initialized to the ╥Chooser╙ name)
  119.  *  TIME            the current time
  120.  *    DATE            the current date
  121.  *    FREEMEM            the amount of free memory 
  122.  */
  123.      *tempValue = '\0';
  124.  
  125.      if( strcmp( SHELL_BOOT, varName ) == 0 )
  126.          strcpy( tempValue, bootVol );
  127.      else if( strcmp( SHELL_SHELL, varName ) == 0 )
  128.          GetCurrPath( tempValue );
  129.      else if( strcmp( SHELL_SYSTEMFOLDER, varName ) == 0 )
  130.          GetPathFrom( bootSysRec.sysVRefNum, 0L, tempValue );
  131.      else if( strcmp( SHELL_USER, varName ) == 0 )
  132.          {
  133.          Handle    ph;
  134.          
  135.          ph = GetResource( 'STR ', USERNAMEID );
  136.          if( ph )
  137.              {
  138.              char    *str = *ph;
  139.              PtoCstr( str );
  140.              strcpy( tempValue, str );
  141.              CtoPstr( str );
  142.              }
  143.          }
  144.      else if( strcmp( SHELL_TIME, varName ) == 0 )
  145.          GetShellTime( tempValue );
  146.      else if( strcmp( SHELL_DATE, varName ) == 0 )
  147.          GetShellDate( tempValue );
  148.      else if( strcmp( SHELL_FREEMEM, varName ) == 0 )
  149.          {
  150.          int32    free;
  151.          
  152.          free = FreeMem();
  153.          sprintf( tempValue, "%ld", free );
  154.          }
  155.      else
  156.          {
  157.          char    **ch;
  158.          sprintf( tempValue, "%d_ _%s", (**MyShell).shellID, varName );
  159.          ch = GetShellString( tempValue );
  160.  
  161.          if( ch )
  162.              {
  163.              HLock( ch );
  164.             CopyStr( *ch, tempValue );
  165.             PtoCstr( tempValue );
  166.             HUnlock( ch );
  167.             }
  168.         else
  169.             *tempValue = '\0';
  170.          }
  171.          
  172.     return( tempValue );
  173. }
  174.  
  175. /*******************************************************************/
  176.  
  177. extern    int16    appResFile;
  178.  
  179. void            ShellDumpVar( WHandle ShellWh, int16 ProcID )
  180. {
  181. ShellWindRec    **MyShell;
  182. int16            i, numChars, id;
  183. Handle            h;
  184. int32            num;
  185. char            strnum[ 16 ], *cp, *sp;
  186. char            name[ 256 ];
  187.  
  188.     MyShell = (ShellWindRec **) (**(ShellWh)).thing;
  189.  
  190.     UseResFile( appResFile );
  191.     i = Count1Resources( STRRES );
  192.  
  193.     while( i )
  194.         {
  195.         h = GetIndResource( STRRES, i );
  196.  
  197.         GetResInfo( h, &id, &num, name );
  198.         
  199.         cp = name;
  200.         numChars = *cp++;
  201.         sp = strnum;
  202.         
  203.         while( *cp != '_' && --numChars )        /* copy the shell id */
  204.             *sp++ = *cp++;
  205.         
  206.         if( numChars )
  207.             {
  208.             *sp = '\0';        cp++;    numChars--;
  209.             
  210.             CtoPstr( strnum );
  211.             StringToNum( strnum, &num );
  212.             
  213.             if( num == (int32) (**MyShell).shellID && *cp == ' ' )
  214.                 {
  215.                 sp = name;
  216.     
  217.                 while( *cp++ != '_' )
  218.                     numChars--;
  219.                     
  220.                 while( --numChars )
  221.                     *sp++ = *cp++;
  222.     
  223.                 *sp = '\0';
  224.                 
  225.                 CopyStr( *h, tempValue );
  226.                 PtoCstr( tempValue );
  227.                 procPrintf( ShellWh, ProcID, "%s=%s\n", name, tempValue );
  228.                 }
  229.             }
  230.         i--;
  231.         }
  232.             
  233.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_BOOT,     ShellGetVar( ShellWh, SHELL_BOOT ));
  234.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_SHELL,     ShellGetVar( ShellWh, SHELL_SHELL ));
  235.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_SYSTEMFOLDER, ShellGetVar( ShellWh, SHELL_SYSTEMFOLDER ));
  236.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_USER,     ShellGetVar( ShellWh, SHELL_USER ));
  237.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_TIME,     ShellGetVar( ShellWh, SHELL_TIME ));
  238.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_DATE,     ShellGetVar( ShellWh, SHELL_DATE ));
  239.     procPrintf( ShellWh, ProcID, "%s=%s\n", SHELL_FREEMEM,     ShellGetVar( ShellWh, SHELL_FREEMEM ));
  240. }
  241.  
  242. /*******************************************************************/
  243.  
  244. void            InitShellVars(  WHandle ShellWh )
  245. {
  246. ShellWindRec    **MyShell;
  247.  
  248.     MyShell = (ShellWindRec **) (**(ShellWh)).thing;
  249.  
  250. /*
  251.  *    Standard UNIX variables
  252.  */
  253.     ShellSetVar( ShellWh, SHELL_QUES,        "0" );
  254.     ShellSetVar( ShellWh, SHELL_ZERO,        "Shell" );
  255.     ShellSetVar( ShellWh, SHELL_PND,        "0" );
  256.     ShellSetVar( ShellWh, SHELL_DOLLAR,        "3" );
  257.     ShellSetVar( ShellWh, SHELL_EXCL,        "3" );
  258.     ShellSetVar( ShellWh, SHELL_DASH,        "-" );
  259.     ShellSetVar( ShellWh, SHELL_HOME,        "." );
  260.     ShellSetVar( ShellWh, SHELL_CDPATH,        "/" );
  261.     ShellSetVar( ShellWh, SHELL_PATH,        ".;/" );
  262.     ShellSetVar( ShellWh, SHELL_PS1,        "$" );
  263.     ShellSetVar( ShellWh, SHELL_PS2,        ">" );
  264.     ShellSetVar( ShellWh, SHELL_IFS,        " \n\t" );
  265.     ShellSetVar( ShellWh, SHELL_COMMAND,    "SH" );
  266. }
  267.  
  268.  
  269. /*******************************************************************/
  270.  
  271. Boolean        DoSET( int16 ProcToken, WHandle ShellWh, int16 ProcID, char *string )
  272. {
  273. int16    i, index;
  274. char    var[ 256 ],
  275.         value[ 256 ],
  276.         *cp, *vp;
  277.         
  278. ShellWindRec    **MyShell = (ShellWindRec **) (**ShellWh).thing;
  279.  
  280.     switch( ProcToken )
  281.         {
  282.         case    PROC_INIT    :
  283.             (**MyShell).Proc[ ProcID ].flags = TRUE;
  284.             break;
  285.  
  286.         case    PROC_TERM    :
  287.         case    PROC_BREAK    :
  288.             SendOutToken( ShellWh, ProcID, PROC_BREAK );
  289.             /* Turn ourself off */
  290.             (**MyShell).Proc[ ProcID ].ProcActive = FALSE;
  291.             break;
  292.             
  293.         case    PROC_STDIN    :
  294.             if( (**MyShell).Proc[ ProcID ].flags )
  295.                 {
  296.                 (**MyShell).Proc[ ProcID ].flags = FALSE;
  297.                 if( (**MyShell).Proc[ ProcID ].argc == 1 )
  298.                     ShellDumpVar( ShellWh, ProcID );
  299.                 
  300.                 for( i = 1; i <  (**MyShell).Proc[ ProcID ].argc; i++ )
  301.                     {
  302.                     index = (**MyShell).Proc[ ProcID ].argv[ i ];
  303.                     cp = &((**MyShell).Proc[ ProcID ].cmdline[ index ]);
  304.                     
  305.                     vp = var;
  306.                     while( *vp = *cp )
  307.                         {
  308.                         if( *vp == '=' )
  309.                             {
  310.                             *vp = '\0';
  311.                             vp = value;
  312.                             cp++;
  313.                             }
  314.                         else
  315.                             {
  316.                             vp++;    cp++;
  317.                             }
  318.                         }
  319.                     ShellSetVar( ShellWh, var, value );
  320.                     }
  321.                 }
  322.                 
  323.             /* Tell the shell that we're done */
  324.             SendOutToken(  ShellWh, ProcID, PROC_BREAK );
  325.             
  326.             /* Turn ourself off */
  327.             (**MyShell).Proc[ ProcID ].ProcActive = FALSE;
  328.             return( FALSE );
  329.         }
  330. }
  331.  
  332. /*******************************************************************/
  333.  
  334. Boolean        DoUNSET( int16 ProcToken, WHandle ShellWh, int16 ProcID, char *string )
  335. {
  336. int16            i, argc;
  337. char            argument[ 256 ];
  338. ShellWindRec    **MyShell = (ShellWindRec **) (**ShellWh).thing;
  339.  
  340.     switch( ProcToken )
  341.         {
  342.         case    PROC_INIT    :
  343.             (**MyShell).Proc[ ProcID ].flags = TRUE;
  344.             break;
  345.  
  346.         case    PROC_TERM    :
  347.         case    PROC_BREAK    :
  348.             SendOutToken( ShellWh, ProcID, PROC_BREAK );
  349.             /* Turn ourself off */
  350.             (**MyShell).Proc[ ProcID ].ProcActive = FALSE;
  351.             break;
  352.             
  353.         case    PROC_STDIN    :
  354.             if( (**MyShell).Proc[ ProcID ].flags )
  355.                 {
  356.                 (**MyShell).Proc[ ProcID ].flags = FALSE;
  357.                                 
  358.                 argc = (**MyShell).Proc[ ProcID ].argc;
  359.                 for( i = 1; i < argc; i++ )
  360.                     {
  361.                     GetArgv( ShellWh, ProcID, i, argument );
  362.                     ShellDelVar( ShellWh, argument );
  363.                     }
  364.                 }
  365.                 
  366.             /* Tell the shell that we're done */
  367.             SendOutToken(  ShellWh, ProcID, PROC_BREAK );
  368.             
  369.             /* Turn ourself off */
  370.             (**MyShell).Proc[ ProcID ].ProcActive = FALSE;
  371.             return( FALSE );
  372.         }
  373. }
  374.